package service

import (
	"context"
	"detection-web/internal/dao"
	"detection-web/internal/model/entity"
	"encoding/json"
	"fmt"
	"strings"

	"detection-web/internal/model/dto"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"
)

// OrderData 订单数据结构
type OrderData struct {
	PromotionId string `json:"promotion_id"`
}

// IPromoteOrderService 推广订单服务接口
type IPromoteOrderService interface {
	// GetPromotionIdsByStatus 根据状态获取promotion_id列表
	GetPromotionIdsByStatus(ctx context.Context, status int) ([]string, error)
	// GetOrderDataByStatus 根据状态获取订单数据（包含promotion_id和shop_app_id）
	GetOrderDataByStatus(ctx context.Context, status int) ([]struct {
		PromotionId string `json:"promotion_id"`
		ShopAppId   string `json:"shop_app_id"`
	}, error)
	// GetShopAppIdsByStatus 根据状态获取shop_app_id列表
	GetShopAppIdsByStatus(ctx context.Context, status int) ([]string, error)
	// CheckProductStatus 检查商品状态
	CheckProductStatus(ctx context.Context) (*dto.ProductStatusCheckResponse, error)
}

// promoteOrderService 服务实现
type promoteOrderService struct{}

var localPromoteOrder IPromoteOrderService

// PromoteOrder 获取服务实例
func PromoteOrder() IPromoteOrderService {
	if localPromoteOrder == nil {
		localPromoteOrder = &promoteOrderService{}
	}
	return localPromoteOrder
}

// GetShopAppIdsByStatus 根据状态获取ID列表
func (s *promoteOrderService) GetShopAppIdsByStatus(ctx context.Context, status int) ([]string, error) {
	return dao.PromoteOrder.GetShopAppIdsByStatus(ctx, status)
}

// GetFirstCookie 获取第一个账号的cookie
func (s *promoteOrderService) GetFirstCookie(ctx context.Context) (string, error) {
	// 从item_account表获取
	cookie, err := dao.ItemAccount.GetFirstCookie(ctx)
	if err != nil {
		return "", fmt.Errorf("从数据库获取Cookie失败: %v", err)
	}

	if cookie == "" {
		return "", fmt.Errorf("数据库中没有可用的Cookie")
	}

	g.Log().Infof(ctx, "使用数据库Cookie")
	return cookie, nil
}

// CheckProductStatus 检查商品状态
func (s *promoteOrderService) CheckProductStatus(ctx context.Context) (*dto.ProductStatusCheckResponse, error) {
	// 从promote_order表找到status=2的记录，获取promotion_id
	orderData, err := s.getOrderDataWithStatus2(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取status=2的订单数据失败: %v", err)
	}

	if len(orderData) == 0 {
		return &dto.ProductStatusCheckResponse{
			AbnormalCount: 0,
			TotalCount:    0,
			Results:       []dto.ProductStatusResponse{},
			Message:       "没有需要检查的商品",
		}, nil
	}

	var promotionIds []string
	for _, order := range orderData {
		if order.PromotionId != "" {
			promotionIds = append(promotionIds, order.PromotionId)
		}
	}

	// 获取user_name到export_id的映射
	userNameToExportIds, err := s.getUserNameToExportIdsMap(ctx, promotionIds)
	if err != nil {
		return nil, fmt.Errorf("获取user_name到export_id映射失败: %v", err)
	}

	if len(userNameToExportIds) == 0 {
		return &dto.ProductStatusCheckResponse{
			AbnormalCount: 0,
			TotalCount:    0,
			Results:       []dto.ProductStatusResponse{},
			Message:       "没有找到对应的商品信息",
		}, nil
	}

	var userNames []string
	for userName := range userNameToExportIds {
		userNames = append(userNames, userName)
	}

	//// 限制为前20条进行测试
	//if len(userNames) > 20 {
	//	userNames = userNames[:20]
	//	g.Log().Infof(ctx, "测试模式：限制处理前20条数据")
	//
	//	// 同时需要过滤userNameToExportIds映射，只保留前20个用户的数据
	//	filteredUserNameToExportIds := make(map[string][]string)
	//	for _, userName := range userNames {
	//		if exportIds, exists := userNameToExportIds[userName]; exists {
	//			filteredUserNameToExportIds[userName] = exportIds
	//		}
	//	}
	//	userNameToExportIds = filteredUserNameToExportIds
	//}

	totalRecordCount := len(orderData)

	g.Log().Infof(ctx, "==========================================")
	g.Log().Infof(ctx, "开始处理状态为2的数据:")
	g.Log().Infof(ctx, "总记录数: %d", totalRecordCount)
	g.Log().Infof(ctx, "去重后的user_name数量: %d", len(userNames))
	if len(userNames) == 20 {
		g.Log().Infof(ctx, "当前为测试模式，只处理前20条数据")
	}
	g.Log().Infof(ctx, "==========================================")

	for i, userName := range userNames {
		exportIds := userNameToExportIds[userName]
		g.Log().Infof(ctx, "user_name[%d]: %s, 对应的export_id数量: %d", i+1, userName, len(exportIds))
		for j, exportId := range exportIds {
			g.Log().Infof(ctx, "  export_id[%d]: %s", j+1, exportId)
		}
	}

	//g.Log().Infof(ctx, "准备开始API调用...")
	//// 添加明确的日志确认用户名数量
	//g.Log().Infof(ctx, "即将调用API的用户名数量: %d", len(userNames))
	//for i, userName := range userNames {
	//	g.Log().Infof(ctx, "API调用列表[%d]: %s", i+1, userName)
	//	if i >= 19 { // 只打印前20个
	//		break
	//	}
	//}

	// 调用API
	apiResponses, err := HttpClient().CallWechatAPIConcurrent(ctx, userNames)
	if err != nil {
		g.Log().Warningf(ctx, "API调用出现部分失败: %v", err)
		if len(apiResponses) == 0 {
			return nil, fmt.Errorf("所有API请求都失败了: %v", err)
		}
		g.Log().Infof(ctx, "继续处理成功的 %d 个API响应", len(apiResponses))
	}

	// 处理API响应
	return s.processAPIResponsesSequential(ctx, apiResponses, userNameToExportIds, totalRecordCount)
}

// GetPromotionIdsByStatus 根据状态获取promotion_id列表
func (s *promoteOrderService) GetPromotionIdsByStatus(ctx context.Context, status int) ([]string, error) {
	return dao.PromoteOrder.GetPromotionIdsByStatus(ctx, status)
}

// GetOrderDataByStatus 根据状态获取订单数据（包含promotion_id和shop_app_id）
func (s *promoteOrderService) GetOrderDataByStatus(ctx context.Context, status int) ([]struct {
	PromotionId string `json:"promotion_id"`
	ShopAppId   string `json:"shop_app_id"`
}, error) {
	return dao.PromoteOrder.GetOrderDataByStatus(ctx, status)
}

// processAPIResponsesSequential 逐条处理API响应
func (s *promoteOrderService) processAPIResponsesSequential(ctx context.Context, apiResponses map[string][]byte, userNameToExportIds map[string][]string, totalRecordCount int) (*dto.ProductStatusCheckResponse, error) {
	if len(apiResponses) == 0 {
		return &dto.ProductStatusCheckResponse{
			AbnormalCount: 0,
			TotalCount:    0,
			Results:       []dto.ProductStatusResponse{},
			Message:       "没有API响应数据",
		}, nil
	}

	// 记录处理统计
	g.Log().Infof(ctx, "开始处理 %d 个API响应", len(apiResponses))

	// 逐条处理每个export_id，保持与之前处理逻辑的一致性
	var allResults []dto.ProductStatusResponse
	abnormalCount := 0
	normalCount := 0
	totalProcessedCount := 0

	// 遍历每个API响应
	for userName, apiData := range apiResponses {
		g.Log().Infof(ctx, "正在处理user_name: %s", userName)

		// 获取该user_name对应的export_id列表
		exportIds := userNameToExportIds[userName]
		if len(exportIds) == 0 {
			g.Log().Warningf(ctx, "user_name %s 没有对应的export_id", userName)
			continue
		}

		g.Log().Infof(ctx, "user_name %s 有 %d 个export_id需要处理", userName, len(exportIds))

		// 逐条处理每个export_id
		for _, exportId := range exportIds {
			totalProcessedCount++
			g.Log().Infof(ctx, "正在处理第 %d 条记录: user_name=%s, export_id=%s", totalProcessedCount, userName, exportId)

			// 查找对应的商品状态
			productStatus := s.findProductByExportId(ctx, userName, apiData, exportId)

			if productStatus != nil {
				// 过滤掉状态为2但商品状态正常的商品，只添加异常状态的商品
				if productStatus.ProductStatus != "正常" {
					allResults = append(allResults, *productStatus)
					abnormalCount++
					g.Log().Infof(ctx, "发现异常商品: user_name=%s, export_id=%s, 状态=%s",
						userName, exportId, productStatus.ProductStatus)

					// 将异常商品信息写入item_status表
					if err := s.saveAbnormalItemStatus(ctx, productStatus.ExportId, productStatus.ProductStatus); err != nil {
						g.Log().Errorf(ctx, "保存异常商品状态到数据库失败: export_id=%s, error=%v", productStatus.ExportId, err)
					} else {
						g.Log().Infof(ctx, "成功保存异常商品状态到数据库: export_id=%s, status=%s", productStatus.ExportId, productStatus.ProductStatus)
					}
				} else {
					normalCount++
					g.Log().Infof(ctx, "商品状态正常: user_name=%s, export_id=%s", userName, exportId)
				}
			} else {
				g.Log().Warningf(ctx, "未找到商品: user_name=%s, export_id=%s", userName, exportId)
			}

			// 每处理10条记录打印一次进度
			if totalProcessedCount%10 == 0 {
				g.Log().Infof(ctx, "已处理 %d 条记录，当前进度: %.1f%%",
					totalProcessedCount, float64(totalProcessedCount)/float64(totalRecordCount)*100)
			}
		}

		g.Log().Infof(ctx, "完成处理user_name %s: 处理了 %d 个export_id", userName, len(exportIds))
	}

	g.Log().Infof(ctx, "所有记录处理完成: 总处理数 %d, 正常商品 %d, 异常商品 %d",
		totalProcessedCount, normalCount, abnormalCount)

	// 在控制台最后结束的时候打印出状态为2的共有多少条数据
	g.Log().Infof(ctx, "==========================================")
	g.Log().Infof(ctx, "状态为2的数据统计:")
	g.Log().Infof(ctx, "总记录数: %d", totalRecordCount)
	g.Log().Infof(ctx, "正常商品数: %d", normalCount)
	g.Log().Infof(ctx, "异常商品数: %d", abnormalCount)
	g.Log().Infof(ctx, "==========================================")

	// 返回结果
	response := &dto.ProductStatusCheckResponse{
		AbnormalCount: abnormalCount,
		NormalCount:   normalCount,
		Results:       allResults,
		TotalCount:    totalRecordCount,
	}

	// 添加处理统计信息
	if len(apiResponses) < len(userNameToExportIds) {
		response.Message = fmt.Sprintf("部分处理完成: 成功处理 %d/%d 个user_name，处理了 %d 条记录，找到 %d 个异常商品",
			len(apiResponses), len(userNameToExportIds), totalProcessedCount, abnormalCount)
	} else {
		response.Message = fmt.Sprintf("全部处理完成: 成功处理 %d 个user_name，处理了 %d 条记录，找到 %d 个异常商品",
			len(apiResponses), totalProcessedCount, abnormalCount)
	}

	return response, nil
}

// getPromotionToExportIdsMap 根据promotion_id获取export_id的映射
func (s *promoteOrderService) getPromotionToExportIdsMap(ctx context.Context, orderData []OrderData) (map[string][]string, error) {
	promotionToExportIds := make(map[string][]string)

	// 提取所有promotion_id
	var promotionIds []string
	for _, order := range orderData {
		if order.PromotionId != "" {
			promotionIds = append(promotionIds, order.PromotionId)
		}
	}

	if len(promotionIds) == 0 {
		return promotionToExportIds, nil
	}

	// 分批查询promote_order_material表
	batchSize := 100
	for i := 0; i < len(promotionIds); i += batchSize {
		end := i + batchSize
		if end > len(promotionIds) {
			end = len(promotionIds)
		}

		batchPromotionIds := promotionIds[i:end]

		materials, err := dao.PromoteOrderMaterial.Ctx(ctx).
			Fields("promotion_id,export_id").
			WhereIn("promotion_id", batchPromotionIds).
			All()

		if err != nil {
			return nil, fmt.Errorf("查询promote_order_material表失败: %v", err)
		}

		// 遍历promote_order_material表，将promotion_id和export_id映射
		for _, material := range materials {
			promotionId := material["promotion_id"].String()
			exportId := material["export_id"].String()

			if promotionId != "" && exportId != "" {
				promotionToExportIds[promotionId] = append(promotionToExportIds[promotionId], exportId)
			} else {
				g.Log().Warningf(ctx, "跳过无效记录: promotion_id='%s', export_id='%s'", promotionId, exportId)
			}
		}
	}

	return promotionToExportIds, nil
}

// getUserNameToExportIdsMap 根据promotion_id获取user_name和export_id的映射
func (s *promoteOrderService) getUserNameToExportIdsMap(ctx context.Context, promotionIds []string) (map[string][]string, error) {
	userNameToExportIds := make(map[string][]string)

	// 分批查询promote_order_material表
	batchSize := 100
	for i := 0; i < len(promotionIds); i += batchSize {
		end := i + batchSize
		if end > len(promotionIds) {
			end = len(promotionIds)
		}

		batchPromotionIds := promotionIds[i:end]

		materials, err := dao.PromoteOrderMaterial.Ctx(ctx).
			Fields("user_name,export_id").
			WhereIn("promotion_id", batchPromotionIds).
			All()

		if err != nil {
			return nil, fmt.Errorf("查询promote_order_material表失败: %v", err)
		}

		// 遍历promote_order_material表，将user_name和export_id映射到userNameToExportIds中
		for _, material := range materials {
			userName := material["user_name"].String()
			exportId := material["export_id"].String()

			if userName != "" && exportId != "" {
				userNameToExportIds[userName] = append(userNameToExportIds[userName], exportId)
			} else {
				g.Log().Warningf(ctx, "跳过无效记录: userName='%s', exportId='%s'", userName, exportId)
			}
		}
	}

	// 对每个user_name的export_id列表进行去重
	for userName, exportIds := range userNameToExportIds {
		// 使用map进行去重
		uniqueExportIds := make(map[string]bool)
		var deduplicatedExportIds []string

		for _, exportId := range exportIds {
			if !uniqueExportIds[exportId] {
				uniqueExportIds[exportId] = true
				deduplicatedExportIds = append(deduplicatedExportIds, exportId)
			}
		}

		// 更新去重后的结果
		userNameToExportIds[userName] = deduplicatedExportIds

		// 记录去重信息
		if len(exportIds) != len(deduplicatedExportIds) {
			g.Log().Infof(ctx, "user_name %s: 去重前 %d 个export_id，去重后 %d 个export_id",
				userName, len(exportIds), len(deduplicatedExportIds))
		}
	}

	return userNameToExportIds, nil
}

// getOrderDataWithStatus2 获取status=2的订单数据（包含promotion_id）
func (s *promoteOrderService) getOrderDataWithStatus2(ctx context.Context) ([]OrderData, error) {
	var orderData []OrderData
	batchSize := 100
	offset := 0

	for {
		// 分批查询promote_order表中status=2的记录
		orders, err := dao.PromoteOrder.Ctx(ctx).
			Fields("promotion_id").
			Where("status", 2).
			Limit(batchSize).
			Offset(offset).
			All()

		if err != nil {
			return nil, fmt.Errorf("查询promote_order表失败: %v", err)
		}

		// 如果没有更多数据，退出循环
		if len(orders) == 0 {
			break
		}

		// 处理当前批次的数据
		for _, order := range orders {
			promotionId := order["promotion_id"].String()

			if promotionId != "" {
				orderData = append(orderData, OrderData{
					PromotionId: promotionId,
				})
			}
		}
		if len(orders) < batchSize {
			break
		}

		// 准备下一批
		offset += batchSize
	}

	return orderData, nil
}

// findAllProductsByExportIds 根据export_id列表在API响应中查找所有匹配的商品并检查状态
func (s *promoteOrderService) findAllProductsByExportIds(ctx context.Context, userName string, apiData []byte, exportIds []string) []dto.ProductStatusResponse {
	// 解析API响应
	var apiResponse map[string]interface{}
	if err := json.Unmarshal(apiData, &apiResponse); err != nil {
		return []dto.ProductStatusResponse{{
			ExportId:      "",
			ProductStatus: "异常：API响应解析失败",
		}}
	}

	// 提取商品列表
	var products []interface{}

	if data, ok := apiResponse["data"].(map[string]interface{}); ok {
		// 从data.objects中提取商品列表
		if objects, ok := data["objects"].([]interface{}); ok {
			products = objects
		}
	}

	if len(products) == 0 {
		// 如果没有商品数据，为每个export_id创建一个异常状态
		var results []dto.ProductStatusResponse
		for _, exportId := range exportIds {
			results = append(results, dto.ProductStatusResponse{
				ExportId:      exportId,
				ProductStatus: "异常：API响应中没有商品数据",
			})
		}
		return results
	}

	// 创建export_id集合，用于快速查找
	exportIdSet := make(map[string]bool)
	for _, exportId := range exportIds {
		exportIdSet[exportId] = true
	}

	// 记录找到的匹配商品数量
	foundCount := 0
	var foundProducts []dto.ProductStatusResponse

	// 在商品列表中查找所有匹配的export_id
	for _, product := range products {
		productMap, ok := product.(map[string]interface{})
		if !ok {
			continue
		}

		// 提取商品的exportId
		productExportId, ok := productMap["exportId"].(string)
		if !ok || productExportId == "" {
			continue
		}

		// 检查是否在目标export_id列表中
		if exportIdSet[productExportId] {
			foundCount++
			// 找到匹配的商品，检查其状态
			productStatus := s.checkProductStatus(userName, productMap, productExportId)
			foundProducts = append(foundProducts, productStatus)

			g.Log().Infof(ctx, "找到匹配商品[%d]: export_id=%s, 状态=%s", foundCount, productExportId, productStatus.ProductStatus)
		}
	}

	// 如果没有找到任何匹配的商品，为每个export_id创建一个异常状态
	if foundCount == 0 {
		var results []dto.ProductStatusResponse
		for _, exportId := range exportIds {
			results = append(results, dto.ProductStatusResponse{
				ExportId:      exportId,
				ProductStatus: "异常：没有找到与数据库中export_id匹配的商品",
			})
		}
		return results
	}

	// 检查是否有未找到的export_id，为它们创建异常状态
	foundExportIdSet := make(map[string]bool)
	for _, product := range foundProducts {
		foundExportIdSet[product.ExportId] = true
	}

	var results []dto.ProductStatusResponse
	results = append(results, foundProducts...)

	// 为未找到的export_id添加异常状态
	for _, exportId := range exportIds {
		if !foundExportIdSet[exportId] {
			results = append(results, dto.ProductStatusResponse{
				ExportId:      exportId,
				ProductStatus: "异常：在API响应中未找到该商品",
			})
		}
	}

	g.Log().Infof(ctx, "用户 %s 共找到 %d 个匹配商品，总共返回 %d 个商品状态",
		userName, foundCount, len(results))

	return results
}

// findProductByExportIds 根据export_id列表在API响应中查找商品并检查状态
func (s *promoteOrderService) findProductByExportIds(ctx context.Context, userName string, apiData []byte, exportIds []string) dto.ProductStatusResponse {
	// 解析API响应
	var apiResponse map[string]interface{}
	if err := json.Unmarshal(apiData, &apiResponse); err != nil {
		return dto.ProductStatusResponse{
			ExportId:      "",
			ProductStatus: "异常：API响应解析失败",
		}
	}

	// 提取商品列表
	var products []interface{}

	if data, ok := apiResponse["data"].(map[string]interface{}); ok {
		// 从data.objects中提取商品列表
		if objects, ok := data["objects"].([]interface{}); ok {
			products = objects
		}
	}

	if len(products) == 0 {
		// 如果没有商品数据，尝试从exportIds中获取第一个作为参考
		exportId := ""
		if len(exportIds) > 0 {
			exportId = exportIds[0]
		}
		return dto.ProductStatusResponse{
			ExportId:      exportId,
			ProductStatus: "异常：API响应中没有商品数据",
		}
	}

	// 创建export_id集合，用于快速查找
	exportIdSet := make(map[string]bool)
	for _, exportId := range exportIds {
		exportIdSet[exportId] = true
	}

	// 记录找到的匹配商品数量
	foundCount := 0
	var foundProducts []dto.ProductStatusResponse

	// 在商品列表中查找所有匹配的export_id
	for _, product := range products {
		productMap, ok := product.(map[string]interface{})
		if !ok {
			continue
		}

		// 提取商品的exportId
		productExportId, ok := productMap["exportId"].(string)
		if !ok || productExportId == "" {
			continue
		}

		// 检查是否在目标export_id列表中
		if exportIdSet[productExportId] {
			foundCount++
			// 找到匹配的商品，检查其状态
			productStatus := s.checkProductStatus(userName, productMap, productExportId)
			foundProducts = append(foundProducts, productStatus)

			g.Log().Infof(ctx, "找到匹配商品[%d]: export_id=%s, 状态=%s", foundCount, productExportId, productStatus.ProductStatus)
		}
	}

	// 如果没有找到任何匹配的商品
	if foundCount == 0 {
		exportId := ""
		if len(exportIds) > 0 {
			exportId = exportIds[0]
		}
		return dto.ProductStatusResponse{
			ExportId:      exportId,
			ProductStatus: "异常：没有找到与数据库中export_id匹配的商品",
		}
	}

	// 如果找到多个商品，返回第一个（或者可以根据需要返回所有）
	firstProduct := foundProducts[0]

	g.Log().Infof(ctx, "用户 %s 共找到 %d 个匹配商品，返回第一个商品状态: export_id=%s, 状态=%s",
		userName, foundCount, firstProduct.ExportId, firstProduct.ProductStatus)

	return firstProduct
}

// checkProductStatus 检查商品状态
func (s *promoteOrderService) checkProductStatus(userName string, productMap map[string]interface{}, exportId string) dto.ProductStatusResponse {
	productStatus := "正常"

	// 检查shoppingcartJumpinfo中的path
	if jumpInfo, ok := productMap["shoppingcartJumpinfo"].(map[string]interface{}); ok {
		// 检查path是否包含error
		if pathStr, ok := jumpInfo["path"].(string); ok {
			if strings.Contains(pathStr, "error") {
				productStatus = "商品已下架"
			}
		}
	}

	fmt.Printf("用户 %s 商品状态检查: export_id=%s, 状态=%s\n", userName, exportId, productStatus)

	return dto.ProductStatusResponse{
		ExportId:      exportId,
		ProductStatus: productStatus,
	}
}

// findProductByExportId 根据单个export_id在API响应中查找商品并检查状态
func (s *promoteOrderService) findProductByExportId(ctx context.Context, userName string, apiData []byte, exportId string) *dto.ProductStatusResponse {
	// 解析API响应
	var apiResponse map[string]interface{}
	if err := json.Unmarshal(apiData, &apiResponse); err != nil {
		return &dto.ProductStatusResponse{
			ExportId:      exportId,
			ProductStatus: "异常：API响应解析失败",
		}
	}

	// 提取商品列表
	var products []interface{}

	if data, ok := apiResponse["data"].(map[string]interface{}); ok {
		// 从data.objects中提取商品列表
		if objects, ok := data["objects"].([]interface{}); ok {
			products = objects
		}
	}

	if len(products) == 0 {
		return &dto.ProductStatusResponse{
			ExportId:      exportId,
			ProductStatus: "异常：API响应中没有商品数据",
		}
	}

	// 在商品列表中查找匹配的export_id
	for _, product := range products {
		productMap, ok := product.(map[string]interface{})
		if !ok {
			continue
		}

		// 提取商品的exportId
		productExportId, ok := productMap["exportId"].(string)
		if !ok || productExportId == "" {
			continue
		}

		// 检查是否匹配目标export_id
		if productExportId == exportId {
			// 找到匹配的商品，检查其状态
			productStatus := s.checkProductStatus(userName, productMap, exportId)
			return &productStatus
		}
	}

	// 如果没有找到匹配的商品
	return &dto.ProductStatusResponse{
		ExportId:      exportId,
		ProductStatus: "异常：没有找到与数据库中export_id匹配的商品",
	}
}

// saveAbnormalItemStatus 保存异常商品状态到item_status表
func (s *promoteOrderService) saveAbnormalItemStatus(ctx context.Context, exportId, productStatus string) error {
	// 创建item_status实体
	itemStatus := &entity.ItemStatus{
		ExportId:      exportId,
		ProductStatus: productStatus,
		CreatedAt:     gtime.Now(),
	}

	// 插入数据库
	_, err := dao.ItemStatus.Ctx(ctx).Data(itemStatus).Insert()
	if err != nil {
		return fmt.Errorf("插入item_status表失败: %v", err)
	}

	return nil
}
